//================================================================================================================================
//
// Copyright (c) 2015-2022 VisionStar Information Technology (Shanghai) Co., Ltd. All Rights Reserved.
// EasyAR is the registered trademark or trademark of VisionStar Information Technology (Shanghai) Co., Ltd in China
// and other countries for the augmented reality technology developed by VisionStar Information Technology (Shanghai) Co., Ltd.
//
//================================================================================================================================

package com.lyc.easyar;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.ImageFormat;
import android.graphics.Rect;
import android.graphics.SurfaceTexture;
import android.graphics.YuvImage;
import android.hardware.Camera;
import android.hardware.Camera.CameraInfo;
import android.hardware.Camera.PreviewCallback;
import android.os.SystemClock;
import android.util.Log;

import com.lyc.easyar.utils.EasyARCore;
import com.lyc.easyar.utils.BitmapUtil;
import com.lyc.easyar.utils.Constant;

import java.io.ByteArrayOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

import cn.easyar.CameraDeviceFocusMode;
import cn.easyar.CameraDeviceType;
import cn.easyar.CameraParameters;
import cn.easyar.FunctorOfVoidFromInputFrame;
import cn.easyar.InputFrame;
import cn.easyar.PixelFormat;
import cn.easyar.Vec2I;

@SuppressWarnings("deprecation")
class CameraDeviceCamera implements CameraDevice, PreviewCallback {
    private static final String TAG = "EasyAR";

    private final FunctorOfVoidFromInputFrame mInputFrameHandler;
    private CameraParameters mCameraParameters;
    private int mBufferCapacity = 8;
    private AtomicInteger mBufferSize = new AtomicInteger(8);
    private int mCameraIndex = -1;
    private int mCameraDeviceType = CameraDeviceType.Unknown;
    private int mCameraOrientation = 0;

    private List<Camera.Size> mSupportedPreviewSizes;
    private List<int[]> mSupportedPreviewFpsRanges;
    private int mWidth = Constant.SHOOT_PIC_WIDTH;
    private int mHeight = Constant.SHOOT_PIC_HEIGHT;
    private Vec2I mSizeToSet = new Vec2I(mWidth, mHeight);
    private int mCurrentFpsRange = -1;
    private Boolean mFlashTorchMode = null;
    private Integer mFocusMode = null;

    private boolean mStarted = false;

    private volatile Camera mCameraDevice; //we check mCameraDevice == null in different threads, which requires 'volatile' to gain Load-Acquire/Store-Release semantics on ARM processors, which may trigger 'getParameters failed' in getSizeHeight from CameraDevice::onPause()
    private SurfaceTexture mSurfaceTexture;
    private boolean isAllowTakePhoto;
    private PathCallback pathCallback;

    public CameraDeviceCamera(Context context, FunctorOfVoidFromInputFrame inputFrameHandler) {
        this.mInputFrameHandler = inputFrameHandler;
        this.mCameraParameters = CameraParameters.createWithDefaultIntrinsics(new Vec2I(640, 480), CameraDeviceType.Unknown, 0);
    }

    @Override
    public int getBufferCapacity() {
        return mBufferCapacity;
    }

    @Override
    public void setBufferCapacity(int capacity) {
        mBufferCapacity = capacity;
        if (ready()) {
            for (int k = mBufferSize.get(); k < capacity; k += 1) {
                mCameraDevice.addCallbackBuffer(new byte[mWidth * mHeight * 3 / 2]);
            }
            mBufferSize.set(mBufferCapacity);
        }
    }

    @Override
    public void takePhoto(PathCallback callback){
        this.pathCallback = callback;
        this.isAllowTakePhoto = true;
    }

    /**
     * 检测是否支持调节焦距
     */
    private boolean isSupportZoom(Camera.Parameters mParameters) {
        boolean isSupport = true;
        if (mParameters != null && mParameters.isSmoothZoomSupported()) {
            isSupport = false;
        }
        return isSupport;
    }

    @Override
    public void setZoom(int progress, int max) {
        if(mCameraDevice == null){
            return;
        }

        Camera.Parameters params = mCameraDevice.getParameters();
        if (isSupportZoom(params)) {
            try {
                int maxZoom = params.getMaxZoom();
                if (maxZoom == 0) {
                    return;
                }
                //确保value>=0且value<=maxZoom
                int value = Math.max(0, Math.min(progress, maxZoom));
                params.setZoom(value);

                mCameraDevice.setParameters(params);
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            Log.d("PhotoTransNewFragment","--------the phone not support zoom");
        }
    }

    @Override
    public int getMaxZoom() {
        if(mCameraDevice == null){
            return 0;
        }
        Camera.Parameters params = mCameraDevice.getParameters();
        return params.getMaxZoom();
    }

    @Override
    public int getZoomValue() {
        if(mCameraDevice == null){
            return 0;
        }
        Camera.Parameters params = mCameraDevice.getParameters();
        return params.getZoom();
    }

    @Override
    public void changeZoom(boolean isAdd) {
        int maxZoom = getMaxZoom();
        if(maxZoom == 0) return;
        int increment = maxZoom/ 10;//增量
        int zoomValue = getZoomValue();
        if(isAdd){
            zoomValue += increment;
        }else {
            zoomValue -= increment;
        }

        setZoom(zoomValue, maxZoom);
    }

    @Override
    public boolean openWithIndex(int index) {
        try {
            close();
            mSurfaceTexture = new SurfaceTexture(0);
            mCameraDevice = Camera.open(index);
            if (mCameraDevice != null) {
                mCameraIndex = index;
                CameraInfo cameraInfo = new CameraInfo();
                Camera.getCameraInfo(mCameraIndex, cameraInfo);
                mCameraDeviceType = CameraDeviceType.Unknown;
                if (cameraInfo.facing == CameraInfo.CAMERA_FACING_BACK) {
                    mCameraDeviceType = CameraDeviceType.Back;
                } else if (cameraInfo.facing == CameraInfo.CAMERA_FACING_FRONT) {
                    mCameraDeviceType = CameraDeviceType.Front;
                }
                mCameraOrientation = cameraInfo.orientation;

                if (mCameraParameters != null) {
                    mCameraParameters.dispose();
                }
                mCameraParameters = CameraParameters.createWithDefaultIntrinsics(new Vec2I(mWidth, mHeight), mCameraDeviceType, mCameraOrientation);

                Camera.Parameters params = mCameraDevice.getParameters();
                params.setPreviewFormat(ImageFormat.NV21); //always supported
                mSupportedPreviewSizes = params.getSupportedPreviewSizes();
                mSupportedPreviewFpsRanges = params.getSupportedPreviewFpsRange();

                if ((mCurrentFpsRange < 0) || (mCurrentFpsRange >= mSupportedPreviewFpsRanges.size())) {
                    mCurrentFpsRange = mSupportedPreviewFpsRanges.size() - 1;
                    int i = 0;
                    for (int[] range : mSupportedPreviewFpsRanges) {
                        if ((range[0] == 30000) && (range[1] == 30000)) {
                            mCurrentFpsRange = i;
                        }
                        i += 1;
                    }
                    params.setPreviewFpsRange(mSupportedPreviewFpsRanges.get(mCurrentFpsRange)[0], mSupportedPreviewFpsRanges.get(mCurrentFpsRange)[1]);
                }

                Camera.Size size = getOptimalPreviewSize(mSizeToSet.data[0], mSizeToSet.data[1]);
                params.setPreviewSize(size.width, size.height);
                mCameraDevice.setParameters(params);
                params = mCameraDevice.getParameters();
                size = params.getPreviewSize();
                mWidth = size.width;
                mHeight = size.height;
                if (mCameraParameters != null) {
                    mCameraParameters.dispose();
                }
                mCameraParameters = CameraParameters.createWithDefaultIntrinsics(new Vec2I(mWidth, mHeight), mCameraDeviceType, mCameraOrientation);

                mCameraDevice.setParameters(params);

                setFrameRateRange(mCurrentFpsRange);
                return true;
            }
        } catch (Exception e) {
            Log.e(TAG, "Camera1: \n" + Log.getStackTraceString(e));
            if (mCameraDevice != null) {
                try {
                    mCameraDevice.release();
                } catch (Exception ex) {
                }
                mCameraDevice = null;
            }
            return false;
        }
        return false;
    }

    @Override
    public boolean openWithSpecificType(int type) {
        CameraInfo cameraInfo = new CameraInfo();
        int cameraCount = Camera.getNumberOfCameras();
        for (int k = 0; k < cameraCount; k += 1) {
            Camera.getCameraInfo(k, cameraInfo);
            if ((type == CameraDeviceType.Back) && (cameraInfo.facing == CameraInfo.CAMERA_FACING_BACK)) {
                return openWithIndex(k);
            }
            if ((type == CameraDeviceType.Front) && (cameraInfo.facing == CameraInfo.CAMERA_FACING_FRONT)) {
                return openWithIndex(k);
            }
            if (type == CameraDeviceType.Unknown) {
                return openWithIndex(k);
            }
        }
        return false;
    }

    @Override
    public void close() {
        stop();
        if (mCameraParameters != null) {
            mCameraParameters.dispose();
            mCameraParameters = null;
        }
        if (mSurfaceTexture != null) {
            mSurfaceTexture.release();
            mSurfaceTexture = null;
        }
    }

    @Override
    public boolean start() {
        if (!ready()) {
            if (!openWithIndex(mCameraIndex)) {
                return false;
            }
        }

        try {
            mCameraDevice.setPreviewTexture(mSurfaceTexture);
            mCameraDevice.setPreviewCallbackWithBuffer(this);
            for (int i = 0; i < mBufferCapacity; i += 1) {
                mCameraDevice.addCallbackBuffer(new byte[mWidth * mHeight * 3 / 2]);
            }
            mBufferSize.set(mBufferCapacity);
            mCameraDevice.startPreview();
        } catch (Exception e) {
            Log.e(TAG, "Camera1: \n" + Log.getStackTraceString(e));
            return false;
        }
        if (mFlashTorchMode != null) {
            setFlashTorchMode(mFlashTorchMode);
        }
        if (mFocusMode != null) {
            setFocusMode(mFocusMode);
        }
        mStarted = true;
        return true;
    }

    @Override
    public void stop() {
        if (!ready())
            return;

        mStarted = false;
        try {
            mCameraDevice.stopPreview();
        } catch (Exception ex) {
        }
        try {
            mCameraDevice.setPreviewCallback(null);
        } catch (Exception ex) {
        }
        try {
            mCameraDevice.release();
        } catch (Exception ex) {
        }
        mCameraDevice = null;
    }

    @Override
    public int getIndex() {
        return mCameraIndex;
    }

    @Override
    public int getType() {
        return mCameraDeviceType;
    }

    @Override
    public int getCameraOrientation() {
        return mCameraOrientation;
    }

    @Override
    public CameraParameters getCameraParameters() {
        return new CameraParameters(mCameraParameters.size(), mCameraParameters.focalLength(), mCameraParameters.principalPoint(), mCameraParameters.cameraDeviceType(), mCameraParameters.cameraOrientation());
    }

    @Override
    public void setCameraParameters(CameraParameters cameraParameters) {
        if (cameraParameters == null) { return; }
        if (mCameraParameters != null) {
            mCameraParameters.dispose();
        }
        mCameraParameters = new CameraParameters(cameraParameters.size(), cameraParameters.focalLength(), cameraParameters.principalPoint(), cameraParameters.cameraDeviceType(), cameraParameters.cameraOrientation());
    }

    @Override
    public int getSizeWidth(){
        return mWidth;
    }

    @Override
    public int getSizeHeight(){
        return mHeight;
    }

    @Override
    public int getNumSupportedSize(){
        if (mSupportedPreviewSizes == null) { return 0; }
        return mSupportedPreviewSizes.size();
    }

    @Override
    public int getSupportedSizeWidth(int index){
        if (mSupportedPreviewSizes == null) { return 0; }
        if ((index < 0) || (index >= mSupportedPreviewSizes.size())) { return 0; }
        Camera.Size size = mSupportedPreviewSizes.get(index);
        return size.width;
    }

    @Override
    public int getSupportedSizeHeight(int index){
        if (mSupportedPreviewSizes == null) { return 0; }
        if ((index < 0) || (index >= mSupportedPreviewSizes.size())) { return 0; }
        Camera.Size size = mSupportedPreviewSizes.get(index);
        return size.height;
    }

    @Override
    public boolean setSize(int width, int height) {
        mSizeToSet = new Vec2I(width, height);
        if (!ready()) { return false; }

        try {
            boolean started = mStarted;
            if (started) {
                close();
                start();
            }
            return true;
        } catch (Exception e) {
            Log.e(TAG, "Camera1: \n" + Log.getStackTraceString(e));
            return false;
        }
    }

    @Override
    public int getNumSupportedFrameRateRange() {
        if (mSupportedPreviewFpsRanges == null) { return 0; }
        return mSupportedPreviewFpsRanges.size();
    }

    @Override
    public float getSupportedFrameRateRangeLower(int index) {
        if (mSupportedPreviewFpsRanges == null) { return 0; }
        if ((index < 0) || (index >= mSupportedPreviewFpsRanges.size())) { return 0; }
        return mSupportedPreviewFpsRanges.get(index)[0] / 1000.0f;
    }

    @Override
    public float getSupportedFrameRateRangeUpper(int index) {
        if (mSupportedPreviewFpsRanges == null) { return 0; }
        if ((index < 0) || (index >= mSupportedPreviewFpsRanges.size())) { return 0; }
        return mSupportedPreviewFpsRanges.get(index)[1] / 1000.0f;
    }

    @Override
    public int getFrameRateRange() {
        if (mSupportedPreviewFpsRanges == null) { return -1; }
        return mCurrentFpsRange;
    }

    @Override
    public boolean setFrameRateRange(int index) {
        if (mSupportedPreviewFpsRanges == null) { return false; }
        if ((index < 0) || (index >= mSupportedPreviewFpsRanges.size())) { return false; }
        mCurrentFpsRange = index;

        try {
            Camera.Parameters params = mCameraDevice.getParameters();
            params.setPreviewFpsRange(mSupportedPreviewFpsRanges.get(mCurrentFpsRange)[0], mSupportedPreviewFpsRanges.get(mCurrentFpsRange)[1]);
            mCameraDevice.setParameters(params);
            return true;
        } catch (Exception e) {
            Log.e(TAG, "Camera1: \n" + Log.getStackTraceString(e));
            return false;
        }
    }

    @Override
    public boolean setFlashTorchMode(boolean on) {
        if (!ready()) {
            mFlashTorchMode = on;
            return false;
        }

        try {
            Camera.Parameters params = mCameraDevice.getParameters();
            String mode = null;
            if (on) {
                mode = Camera.Parameters.FLASH_MODE_TORCH;
            } else {
                mode = Camera.Parameters.FLASH_MODE_OFF;
            }
            List<String> supported = mCameraDevice.getParameters().getSupportedFlashModes();
            if ((supported != null) && (supported.contains(mode))) {
                params.setFlashMode(mode);
                mCameraDevice.setParameters(params);
                mFlashTorchMode = on;
                return true;
            }

            return false;
        } catch (Exception e) {
            Log.e(TAG, "Camera1: \n" + Log.getStackTraceString(e));
            return false;
        }
    }

    @Override
    public boolean setFocusMode(int focusMode) {
        if (!ready()) {
            mFocusMode = focusMode;
            return false;
        }

        try {
            Camera.Parameters params = mCameraDevice.getParameters();
            List<String> modes = params.getSupportedFocusModes();
            switch (focusMode){
                case CameraDeviceFocusMode.Normal:
                    if (modes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
                        params.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
                    } else {
                        return false;
                    }
                    break;
                case CameraDeviceFocusMode.Continousauto:
                    if (modes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
                        params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
                    } else if (modes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) {
                        params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
                    } else {
                        return false;
                    }
                    break;
                case CameraDeviceFocusMode.Infinity:
                    if (modes.contains(Camera.Parameters.FOCUS_MODE_INFINITY)) {
                        params.setFocusMode(Camera.Parameters.FOCUS_MODE_INFINITY);
                    } else {
                        return false;
                    }
                    break;
                case CameraDeviceFocusMode.Macro:
                    if (modes.contains(Camera.Parameters.FOCUS_MODE_MACRO)) {
                        params.setFocusMode(Camera.Parameters.FOCUS_MODE_MACRO);
                    } else {
                        return false;
                    }
                    break;
                case CameraDeviceFocusMode.Medium:
                    return false;
                default:
                    return false;
            }
            mFocusMode = focusMode;
            mCameraDevice.setParameters(params);
            return true;
        } catch (Exception e) {
            Log.e(TAG, "Camera1: \n" + Log.getStackTraceString(e));
            return false;
        }
    }

    @Override
    public boolean autoFocus() {
        try {
            mCameraDevice.autoFocus(new Camera.AutoFocusCallback() {
                public void onAutoFocus(boolean success, Camera camera) {
                    if (mFocusMode != null) {
                        setFocusMode(mFocusMode);
                    }
                }
            });
        } catch (RuntimeException e) {
            e.printStackTrace();
            Log.e(TAG,"Camera1: autoFocus must call after startPreview and in appropriate focus mode");
            return false;
        } catch (Exception e) {
            Log.e(TAG, "Camera1: \n" + Log.getStackTraceString(e));
            return false;
        }
        return true;
    }

    public boolean ready() {
        return mCameraDevice != null;
    }

    private float getRatioError(float x, float x0) {
        float a = (x / Math.max(x0, 1) - 1);
        float b = (x0 / Math.max(x, 1) - 1);
        return a * a + b * b;
    }

    private Camera.Size getOptimalPreviewSize(int width, int height) {
        Camera.Size s = null;
        float minError = Float.MAX_VALUE;
        for (Camera.Size size : mSupportedPreviewSizes) {
            float error = getRatioError(width, size.width) + getRatioError(height, size.height);

            //Log.d("EasyAR", "Camera1: getOptimalPreviewSize: " + width + " " + height + " " + size.width + " " + size.height + " " + error);

            if (error < minError) {
                minError = error;
                s = size;
            }
        }
        return s;
    }

    @Override
    public void onPreviewFrame(byte[] data, Camera camera) {
        if (data == null) return;

        if(isAllowTakePhoto){
            isAllowTakePhoto = false;
            //拍照保存
            final int WIDTH = Constant.SHOOT_PIC_WIDTH;
            final int HEIGHT = Constant.SHOOT_PIC_HEIGHT;
            YuvImage yuvImage = new YuvImage(data, ImageFormat.NV21, WIDTH, HEIGHT, null);
            ByteArrayOutputStream stream = new ByteArrayOutputStream();
            int quality = 100;
            if(stream.size() > 2 * 1024 * 1024){
                quality = 80;//第一次质量压缩
            }
            if (!yuvImage.compressToJpeg(new Rect(0, 0, WIDTH, HEIGHT), quality, stream)) {
                return;
            }
            //----
            byte[] tmp = stream.toByteArray();
            int quality2 = 100;
            if(tmp.length > 2 * 1024 * 1024){
                quality2 = 80;//第二次质量压缩
            }
            Bitmap bmp = BitmapFactory.decodeByteArray(tmp, 0, tmp.length);
            Bitmap bitmapRotated = BitmapUtil.INSTANCE.revolveImageView(90, bmp);//前置摄像头270度，后置摄像头90度
            ByteArrayOutputStream so = new ByteArrayOutputStream();
            bitmapRotated.compress(Bitmap.CompressFormat.JPEG, quality2, so);
            bitmapRotated.recycle();
            //----

            String path = "";
            try{
                String jpgFilePath = EasyARCore.getInstance().getContext().getFilesDir().getAbsolutePath() + "/take_pic.jpg";
                FileOutputStream output = new FileOutputStream(jpgFilePath);
                output.write(so.toByteArray());
                output.flush();
                output.close();
                path = jpgFilePath;
            }catch(FileNotFoundException e){
                e.printStackTrace();
            }catch(IOException e){
                e.printStackTrace();
            }

            if(pathCallback != null){
                pathCallback.onPathBack(path);
            }
        }

        cn.easyar.Buffer b = null;
        cn.easyar.Image i = null;
        InputFrame inputFrame = null;
        CameraParameters camParams = null;
        try {
            b = cn.easyar.Buffer.wrapByteArray(data);
            i = new cn.easyar.Image(b, PixelFormat.YUV_NV21, mWidth, mHeight);
            double double_timestamp = SystemClock.elapsedRealtimeNanos() * 1e-9;
            camParams = mCameraParameters.getResized(new Vec2I(mWidth, mHeight));
            inputFrame = InputFrame.createWithImageAndCameraParametersAndTemporal(i, camParams, double_timestamp);
            mInputFrameHandler.invoke(inputFrame);
        } finally {
            if (camParams != null) { camParams.dispose(); }
            if (inputFrame != null) { inputFrame.dispose(); }
            if (i != null) { i.dispose(); }
            if (b != null) { b.dispose(); }
        }

        if (mBufferSize.get() <= mBufferCapacity) {
            camera.addCallbackBuffer(data);
        } else {
            mBufferSize.getAndDecrement();
        }
    }
}
